home *** CD-ROM | disk | FTP | other *** search
/ Language/OS - Multiplatform Resource Library / LANGUAGE OS.iso / hash / md4.txt < prev    next >
Text File  |  1993-07-23  |  30KB  |  868 lines
  1. The following version of MD4 was taken from sci.crypt.  It was
  2. originally posted in two parts: the code and an appendix.  Both
  3. are included here.
  4. -------------------------------------------------------------------
  5. ___________________________________________________________________
  6. License to copy and use this document and the software described
  7. herein is granted provided it is identified as the "RSA Data
  8. Security, Inc. MD4 Message Digest Algorithm" in all materials
  9. mentioning or referencing this software, function, or document.
  10.  
  11. License is also granted to make derivative works provided that such
  12. works are identified as "derived from the RSA Data Security, Inc. MD4
  13. Message Digest Algorithm" in all material mentioning or referencing
  14. the derived work.
  15.  
  16. RSA Data Security, Inc. makes no representations concerning the
  17. merchantability of this algorithm or software or their suitability
  18. for any specific purpose.  It is provided "as is" without express or
  19. implied warranty of any kind.
  20.  
  21. These notices must be retained in any copies of any part of this
  22. documentation and/or software.
  23.  
  24. APPENDIX. Reference Implementation
  25. ----------------------------------
  26.  
  27. This appendix contains the following files:
  28.     md4.h        -- a header file for using the MD4 implementation
  29.     md4.c        -- the source code for the MD4 routines
  30.     md4driver.c    -- a sample ``user'' routine
  31.     session        -- sample results of running md4driver
  32.  
  33. /* 
  34. ** **************************************************************************
  35. ** md4.h -- Header file for implementation of MD4 Message Digest Algorithm **
  36. ** Updated: 2/13/90 by Ronald L. Rivest                                    **
  37. ** (C) 1990 RSA Data Security, Inc.                                        **
  38. ** **************************************************************************
  39. */
  40.  
  41. /* MDstruct is the data structure for a message digest computation.
  42. */
  43. typedef struct {
  44.   unsigned int buffer[4];    /* Holds 4-word result of MD computation */
  45.   unsigned char count[8];    /* Number of bits processed so far */
  46.   unsigned int done;         /* Nonzero means MD computation finished */
  47. } MDstruct, *MDptr;
  48.  
  49. /* MDbegin(MD)
  50. ** Input: MD -- an MDptr
  51. ** Initialize the MDstruct prepatory to doing a message digest computation.
  52. */
  53. extern void MDbegin();
  54.  
  55. /* MDupdate(MD,X,count)
  56. ** Input: MD -- an MDptr
  57. **        X -- a pointer to an array of unsigned characters.
  58. **        count -- the number of bits of X to use (an unsigned int).
  59. ** Updates MD using the first ``count'' bits of X.
  60. ** The array pointed to by X is not modified.
  61. ** If count is not a multiple of 8, MDupdate uses high bits of last byte.
  62. ** This is the basic input routine for a user.
  63. ** The routine terminates the MD computation when count < 512, so
  64. ** every MD computation should end with one call to MDupdate with a
  65. ** count less than 512.  Zero is OK for a count.
  66. */
  67. extern void MDupdate();
  68.  
  69. /* MDprint(MD)
  70. ** Input: MD -- an MDptr
  71. ** Prints message digest buffer MD as 32 hexadecimal digits.
  72. ** Order is from low-order byte of buffer[0] to high-order byte of buffer[3].
  73. ** Each byte is printed with high-order hexadecimal digit first.
  74. */
  75. extern void MDprint();      
  76.  
  77. /* 
  78. ** End of md4.h
  79. ****************************(cut)*****************************************/
  80.  
  81. /* 
  82. ** **************************************************************************
  83. ** md4.c -- Implementation of MD4 Message Digest Algorithm                 **
  84. ** Updated: 2/16/90 by Ronald L. Rivest                                    **
  85. ** (C) 1990 RSA Data Security, Inc.                                        **
  86. ** **************************************************************************
  87. */
  88.  
  89. /* 
  90. ** To use MD4:
  91. **   -- Include md4.h in your program
  92. **   -- Declare an MDstruct MD to hold the state of the digest computation.
  93. **   -- Initialize MD using MDbegin(&MD)
  94. **   -- For each full block (64 bytes) X you wish to process, call
  95. **          MDupdate(&MD,X,512)
  96. **      (512 is the number of bits in a full block.)
  97. **   -- For the last block (less than 64 bytes) you wish to process,
  98. **          MDupdate(&MD,X,n)
  99. **      where n is the number of bits in the partial block. A partial
  100. **      block terminates the computation, so every MD computation should
  101. **      terminate by processing a partial block, even if it has n = 0.
  102. **   -- The message digest is available in MD.buffer[0] ... MD.buffer[3].
  103. **      (Least-significant byte of each word should be output first.)
  104. **   -- You can print out the digest using MDprint(&MD)
  105. */
  106.  
  107. /* Implementation notes:
  108. ** This implementation assumes that ints are 32-bit quantities.
  109. ** If the machine stores the least-significant byte of an int in the
  110. ** least-addressed byte (eg., VAX and 8086), then LOWBYTEFIRST should be
  111. ** set to TRUE.  Otherwise (eg., SUNS), LOWBYTEFIRST should be set to
  112. ** FALSE.  Note that on machines with LOWBYTEFIRST FALSE the routine
  113. ** MDupdate modifies has a side-effect on its input array (the order of bytes
  114. ** in each word are reversed).  If this is undesired a call to MDreverse(X) can
  115. ** reverse the bytes of X back into order after each call to MDupdate.
  116. */
  117. #define TRUE  1
  118. #define FALSE 0
  119. #define LOWBYTEFIRST FALSE 
  120.  
  121. /* Compile-time includes 
  122. */
  123. #include <stdio.h>
  124. #include "md4.h"
  125.  
  126. /* Compile-time declarations of MD4 ``magic constants''.
  127. */
  128. #define I0  0x67452301       /* Initial values for MD buffer */
  129. #define I1  0xefcdab89
  130. #define I2  0x98badcfe
  131. #define I3  0x10325476
  132. #define C2  013240474631     /* round 2 constant = sqrt(2) in octal */
  133. #define C3  015666365641     /* round 3 constant = sqrt(3) in octal */
  134. /* C2 and C3 are from Knuth, The Art of Programming, Volume 2
  135. ** (Seminumerical Algorithms), Second Edition (1981), Addison-Wesley.
  136. ** Table 2, page 660.
  137. */
  138. #define fs1  3               /* round 1 shift amounts */
  139. #define fs2  7   
  140. #define fs3 11  
  141. #define fs4 19  
  142. #define gs1  3               /* round 2 shift amounts */
  143. #define gs2  5   
  144. #define gs3  9   
  145. #define gs4 13  
  146. #define hs1  3               /* round 3 shift amounts */
  147. #define hs2  9 
  148. #define hs3 11 
  149. #define hs4 15
  150.  
  151.  
  152. /* Compile-time macro declarations for MD4.
  153. ** Note: The ``rot'' operator uses the variable ``tmp''.
  154. ** It assumes tmp is declared as unsigned int, so that the >>
  155. ** operator will shift in zeros rather than extending the sign bit.
  156. */
  157. #define    f(X,Y,Z)             ((X&Y) | ((~X)&Z))
  158. #define    g(X,Y,Z)             ((X&Y) | (X&Z) | (Y&Z))
  159. #define h(X,Y,Z)             (X^Y^Z)
  160. #define rot(X,S)             (tmp=X,(tmp<<S) | (tmp>>(32-S)))
  161. #define ff(A,B,C,D,i,s)      A = rot((A + f(B,C,D) + X[i]),s)
  162. #define gg(A,B,C,D,i,s)      A = rot((A + g(B,C,D) + X[i] + C2),s)
  163. #define hh(A,B,C,D,i,s)      A = rot((A + h(B,C,D) + X[i] + C3),s)
  164.  
  165. /* MDprint(MDp)
  166. ** Print message digest buffer MDp as 32 hexadecimal digits.
  167. ** Order is from low-order byte of buffer[0] to high-order byte of buffer[3].
  168. ** Each byte is printed with high-order hexadecimal digit first.
  169. ** This is a user-callable routine.
  170. */
  171. void 
  172. MDprint(MDp)
  173. MDptr MDp;
  174. { int i,j;
  175.   for (i=0;i<4;i++)
  176.     for (j=0;j<32;j=j+8)
  177.       printf("%02x",(MDp->buffer[i]>>j) & 0xFF);
  178. }
  179.  
  180. /* MDbegin(MDp)
  181. ** Initialize message digest buffer MDp. 
  182. ** This is a user-callable routine.
  183. */
  184. void 
  185. MDbegin(MDp)
  186. MDptr MDp;
  187. { int i;
  188.   MDp->buffer[0] = I0;  
  189.   MDp->buffer[1] = I1;  
  190.   MDp->buffer[2] = I2;  
  191.   MDp->buffer[3] = I3; 
  192.   for (i=0;i<8;i++) MDp->count[i] = 0;
  193.   MDp->done = 0;
  194. }
  195.  
  196. /* MDreverse(X)
  197. ** Reverse the byte-ordering of every int in X.
  198. ** Assumes X is an array of 16 ints.
  199. ** The macro revx reverses the byte-ordering of the next word of X.
  200. */
  201. #define revx { t = (*X << 16) | (*X >> 16); \
  202.            *X++ = ((t & 0xFF00FF00) >> 8) | ((t & 0x00FF00FF) << 8); }
  203. MDreverse(X)
  204. unsigned int *X;
  205. { register unsigned int t;
  206.   revx; revx; revx; revx; revx; revx; revx; revx;
  207.   revx; revx; revx; revx; revx; revx; revx; revx;
  208. }
  209.  
  210. /* MDblock(MDp,X)
  211. ** Update message digest buffer MDp->buffer using 16-word data block X.
  212. ** Assumes all 16 words of X are full of data.
  213. ** Does not update MDp->count.
  214. ** This routine is not user-callable. 
  215. */
  216. static void
  217. MDblock(MDp,X)
  218. MDptr MDp;
  219. unsigned int *X;
  220. { 
  221.   register unsigned int tmp, A, B, C, D;
  222. #if LOWBYTEFIRST == FALSE
  223.   MDreverse(X);
  224. #endif
  225.   A = MDp->buffer[0];
  226.   B = MDp->buffer[1];
  227.   C = MDp->buffer[2];
  228.   D = MDp->buffer[3];
  229.   /* Update the message digest buffer */
  230.   ff(A , B , C , D ,  0 , fs1); /* Round 1 */
  231.   ff(D , A , B , C ,  1 , fs2); 
  232.   ff(C , D , A , B ,  2 , fs3); 
  233.   ff(B , C , D , A ,  3 , fs4); 
  234.   ff(A , B , C , D ,  4 , fs1); 
  235.   ff(D , A , B , C ,  5 , fs2); 
  236.   ff(C , D , A , B ,  6 , fs3); 
  237.   ff(B , C , D , A ,  7 , fs4); 
  238.   ff(A , B , C , D ,  8 , fs1); 
  239.   ff(D , A , B , C ,  9 , fs2); 
  240.   ff(C , D , A , B , 10 , fs3); 
  241.   ff(B , C , D , A , 11 , fs4); 
  242.   ff(A , B , C , D , 12 , fs1); 
  243.   ff(D , A , B , C , 13 , fs2); 
  244.   ff(C , D , A , B , 14 , fs3); 
  245.   ff(B , C , D , A , 15 , fs4); 
  246.   gg(A , B , C , D ,  0 , gs1); /* Round 2 */
  247.   gg(D , A , B , C ,  4 , gs2); 
  248.   gg(C , D , A , B ,  8 , gs3); 
  249.   gg(B , C , D , A , 12 , gs4); 
  250.   gg(A , B , C , D ,  1 , gs1); 
  251.   gg(D , A , B , C ,  5 , gs2); 
  252.   gg(C , D , A , B ,  9 , gs3); 
  253.   gg(B , C , D , A , 13 , gs4); 
  254.   gg(A , B , C , D ,  2 , gs1); 
  255.   gg(D , A , B , C ,  6 , gs2); 
  256.   gg(C , D , A , B , 10 , gs3); 
  257.   gg(B , C , D , A , 14 , gs4); 
  258.   gg(A , B , C , D ,  3 , gs1); 
  259.   gg(D , A , B , C ,  7 , gs2); 
  260.   gg(C , D , A , B , 11 , gs3); 
  261.   gg(B , C , D , A , 15 , gs4);  
  262.   hh(A , B , C , D ,  0 , hs1); /* Round 3 */
  263.   hh(D , A , B , C ,  8 , hs2); 
  264.   hh(C , D , A , B ,  4 , hs3); 
  265.   hh(B , C , D , A , 12 , hs4); 
  266.   hh(A , B , C , D ,  2 , hs1); 
  267.   hh(D , A , B , C , 10 , hs2); 
  268.   hh(C , D , A , B ,  6 , hs3); 
  269.   hh(B , C , D , A , 14 , hs4); 
  270.   hh(A , B , C , D ,  1 , hs1); 
  271.   hh(D , A , B , C ,  9 , hs2); 
  272.   hh(C , D , A , B ,  5 , hs3); 
  273.   hh(B , C , D , A , 13 , hs4); 
  274.   hh(A , B , C , D ,  3 , hs1); 
  275.   hh(D , A , B , C , 11 , hs2); 
  276.   hh(C , D , A , B ,  7 , hs3); 
  277.   hh(B , C , D , A , 15 , hs4);
  278.   MDp->buffer[0] += A; 
  279.   MDp->buffer[1] += B;
  280.   MDp->buffer[2] += C;
  281.   MDp->buffer[3] += D; 
  282. }
  283.  
  284. /* MDupdate(MDp,X,count)
  285. ** Input: MDp -- an MDptr
  286. **        X -- a pointer to an array of unsigned characters.
  287. **        count -- the number of bits of X to use.
  288. **                 (if not a multiple of 8, uses high bits of last byte.)
  289. ** Update MDp using the number of bits of X given by count.
  290. ** This is the basic input routine for an MD4 user.
  291. ** The routine completes the MD computation when count < 512, so
  292. ** every MD computation should end with one call to MDupdate with a
  293. ** count less than 512.  A call with count 0 will be ignored if the
  294. ** MD has already been terminated (done != 0), so an extra call with count
  295. ** 0 can be given as a ``courtesy close'' to force termination if desired.
  296. */
  297. void 
  298. MDupdate(MDp,X,count)
  299. MDptr MDp;
  300. unsigned char *X;
  301. unsigned int count;
  302. { unsigned int i, tmp, bit, byte, mask;
  303.   unsigned char XX[64];
  304.   unsigned char *p;
  305.   /* return with no error if this is a courtesy close with count
  306.   ** zero and MDp->done is true.
  307.   */
  308.   if (count == 0 && MDp->done) return;
  309.   /* check to see if MD is already done and report error */
  310.   if (MDp->done) { printf("\nError: MDupdate MD already done."); return; }
  311.   /* Add count to MDp->count */
  312.   tmp = count;
  313.   p = MDp->count;
  314.   while (tmp)
  315.     { tmp += *p;
  316.       *p++ = tmp;
  317.       tmp = tmp >> 8;
  318.     }
  319.   /* Process data */
  320.   if (count == 512) 
  321.     { /* Full block of data to handle */
  322.       MDblock(MDp,(unsigned int *)X);
  323.     }
  324.   else if (count > 512) /* Check for count too large */
  325.     { printf("\nError: MDupdate called with illegal count value %d.",count);
  326.       return;
  327.     }
  328.   else /* partial block -- must be last block so finish up */
  329.     { /* Find out how many bytes and residual bits there are */
  330.       byte = count >> 3;
  331.       bit =  count & 7;
  332.       /* Copy X into XX since we need to modify it */
  333.       for (i=0;i<=byte;i++)   XX[i] = X[i];
  334.       for (i=byte+1;i<64;i++) XX[i] = 0;
  335.       /* Add padding '1' bit and low-order zeros in last byte */
  336.       mask = 1 << (7 - bit);
  337.       XX[byte] = (XX[byte] | mask) & ~( mask - 1);
  338.       /* If room for bit count, finish up with this block */
  339.       if (byte <= 55)
  340.     { for (i=0;i<8;i++) XX[56+i] = MDp->count[i];
  341.       MDblock(MDp,(unsigned int *)XX);
  342.     }
  343.       else /* need to do two blocks to finish up */
  344.     { MDblock(MDp,(unsigned int *)XX);
  345.       for (i=0;i<56;i++) XX[i] = 0;
  346.       for (i=0;i<8;i++)  XX[56+i] = MDp->count[i];
  347.       MDblock(MDp,(unsigned int *)XX);
  348.     }
  349.       /* Set flag saying we're done with MD computation */
  350.       MDp->done = 1;
  351.     }
  352. }
  353.  
  354. /* 
  355. ** End of md4.c
  356. ****************************(cut)*****************************************/
  357.  
  358. /* 
  359. ** **************************************************************************
  360. ** md4driver.c -- sample routines to test MD4 message digest algorithm.    **
  361. ** Updated: 2/16/90 by Ronald L. Rivest                                    **
  362. ** (C) 1990 RSA Data Security, Inc.                                        **
  363. ** **************************************************************************
  364. */
  365.  
  366. #include <stdio.h>
  367. #include "md4.h"
  368.  
  369. /* MDtimetrial()
  370. ** A time trial routine, to measure the speed of MD4.
  371. ** Measures speed for 1M blocks = 64M bytes.
  372. */
  373. MDtimetrial()
  374. { unsigned int X[16];
  375.   MDstruct MD;
  376.   int i;
  377.   double t;
  378.   for (i=0;i<16;i++) X[i] = 0x01234567 + i;
  379.   printf("MD4 time trial. Processing 1 million 64-character blocks...\n");
  380.   clock();
  381.   MDbegin(&MD);
  382.   for (i=0;i<1000000;i++) MDupdate(&MD,X,512);
  383.   MDupdate(&MD,X,0);
  384.   t = (double) clock(); /* in microseconds */
  385.   MDprint(&MD); printf(" is digest of 64M byte test input.\n");
  386.   printf("Seconds to process test input:   %g\n",t/1e6);
  387.   printf("Characters processed per second: %ld.\n",(int)(64e12/t));
  388. }
  389.  
  390. /* MDstring(s)
  391. ** Computes the message digest for string s.
  392. ** Prints out message digest, a space, the string (in quotes) and a carriage
  393. ** return.
  394. */
  395. MDstring(s)
  396. unsigned char *s;
  397. { unsigned int i, len = strlen(s);
  398.   MDstruct MD;
  399.   MDbegin(&MD);
  400.   for (i=0;i+64<=len;i=i+64) MDupdate(&MD,s+i,512);
  401.   MDupdate(&MD,s+i,(len-i)*8);
  402.   MDprint(&MD);
  403.   printf(" \"%s\"\n",s);
  404. }
  405.  
  406. /* MDfile(filename)
  407. ** Computes the message digest for a specified file.
  408. ** Prints out message digest, a space, the file name, and a carriage return.
  409. */
  410. MDfile(filename)
  411. char *filename;
  412. { FILE *f = fopen(filename,"rb");
  413.   unsigned char X[64];
  414.   MDstruct MD;
  415.   int b;
  416.   if (f == NULL) { printf("%s can't be opened.\n",filename); return; }
  417.   MDbegin(&MD);
  418.   while ((b=fread(X,1,64,f))!=0) MDupdate(&MD,X,b*8);
  419.   MDupdate(&MD,X,0);
  420.   MDprint(&MD);
  421.   printf(" %s\n",filename);
  422.   fclose(f);
  423. }
  424.  
  425. /* MDfilter()
  426. ** Writes the message digest of the data from stdin onto stdout, followed
  427. ** by a carriage return.
  428. */
  429. MDfilter()
  430. { unsigned char X[64];
  431.   MDstruct MD;
  432.   int b;
  433.   MDbegin(&MD);
  434.   while ((b=fread(X,1,64,stdin))!=0) MDupdate(&MD,X,b*8);
  435.   MDupdate(&MD,X,0);
  436.   MDprint(&MD);
  437.   printf("\n");
  438. }
  439.  
  440. /* MDtestsuite()
  441. ** Run a standard suite of test data.
  442. */
  443. MDtestsuite()
  444. {
  445.   printf("MD4 test suite results:\n");
  446.   MDstring("");
  447.   MDstring("a");
  448.   MDstring("abc");
  449.   MDstring("message digest");
  450.   MDstring("abcdefghijklmnopqrstuvwxyz");
  451.   MDstring("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789");
  452.   MDfile("foo"); /* Contents of file foo are "abc" */
  453. }
  454.  
  455. main(argc,argv)
  456. int argc;
  457. char *argv[];
  458. { int i;
  459.   /* For each command line argument in turn:
  460.   ** filename             -- prints message digest and name of file
  461.   ** -sstring             -- prints message digest and contents of string
  462.   ** -t                   -- prints time trial statistics for 64M bytes
  463.   ** -x                   -- execute a standard suite of test data
  464.   ** (no args)            -- writes messages digest of stdin onto stdout
  465.   */
  466.   if (argc==1) MDfilter();
  467.   else
  468.     for (i=1;i<argc;i++)
  469.       if (argv[i][0]=='-' && argv[i][1]=='s') MDstring(argv[i]+2);
  470.       else if (strcmp(argv[i],"-t")==0)       MDtimetrial();
  471.       else if (strcmp(argv[i],"-x")==0)       MDtestsuite();
  472.       else                                    MDfile(argv[i]);
  473. }
  474.  
  475. /*
  476. ** end of md4driver.c
  477. ****************************(cut)*****************************************/
  478.  
  479.  
  480. --------------------------------------------------------------------------
  481. ---- Sample session.  Compiling and using MD4 on SUN Sparcstation --------
  482. --------------------------------------------------------------------------
  483. >ls
  484. total 66
  485. -rw-rw-r--  1 rivest          3 Feb 14 17:40 abcfile
  486. -rwxrwxr-x  1 rivest      24576 Feb 17 12:28 md4
  487. -rw-rw-r--  1 rivest       9347 Feb 17 00:37 md4.c
  488. -rw-rw-r--  1 rivest      25150 Feb 17 12:25 md4.doc
  489. -rw-rw-r--  1 rivest       1844 Feb 16 21:21 md4.h
  490. -rw-rw-r--  1 rivest       3497 Feb 17 12:27 md4driver.c
  491. >
  492. >cc -o md4 -O4 md4.c md4driver.c
  493. md4.c:
  494. md4driver.c:
  495. Linking:
  496. >
  497. >md4 -x
  498. MD4 test suite results:
  499. 31d6cfe0d16ae931b73c59d7e0c089c0 ""
  500. bde52cb31de33e46245e05fbdbd6fb24 "a"
  501. a448017aaf21d8525fc10ae87aa6729d "abc"
  502. d9130a8164549fe818874806e1c7014b "message digest"
  503. d79e1c308aa5bbcdeea8ed63df412da9 "abcdefghijklmnopqrstuvwxyz"
  504. 043f8582f241db351ce627e153e7f0e4 "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789"
  505. a448017aaf21d8525fc10ae87aa6729d abcfile
  506. >
  507. >md4 -sabc -shi
  508. a448017aaf21d8525fc10ae87aa6729d "abc"
  509. cfaee2512bd25eb033236f0cd054e308 "hi"
  510. >
  511. >md4 *
  512. a448017aaf21d8525fc10ae87aa6729d abcfile
  513. d316f994da0e951cf9502928a1f73300 md4
  514. 379adb39eada0dfdbbdfdcd0d9def8c4 md4.c
  515. 9a3f73327c65954198b1f45a3aa12665 md4.doc
  516. 37fe165ac177b461ff78b86d10e4ff33 md4.h
  517. 7dcba2e2dc4d8f1408d08beb17dabb2a md4.o
  518. 08790161bfddc6f5788b4353875cb1c3 md4driver.c
  519. 1f84a7f690b0545d2d0480d5d3c26eea md4driver.o
  520. >
  521. >cat abcfile | md4
  522. a448017aaf21d8525fc10ae87aa6729d
  523. >
  524. >md4 -t
  525. MD4 time trial. Processing 1 million 64-character blocks...
  526. 6325bf77e5891c7c0d8104b64cc6e9ef is digest of 64M byte test input.
  527. Seconds to process test input:   44.0982
  528. Characters processed per second: 1451305.
  529. >
  530. >
  531. ------------------------ end of sample session --------------------------
  532.  
  533. ------------------------------------------------------------------------
  534. ------------------------------------------------------------------------
  535. ------------------------------------------------------------------------
  536. (end of document)
  537.  
  538. From sci.crypt Tue Mar 20 16:02:29 1990
  539. Path: roo!arisia!bionet!uwm.edu!zaphod.mps.ohio-state.edu!tut.cis.ohio-state.edu!ucbvax!hplabs!well!rsa
  540. From: rsa@well.sf.ca.us (RSA Data Security)
  541. Newsgroups: sci.crypt
  542. Subject: MD4 message digest - text
  543. Keywords: message digest, fingerprint, hash, digital signature, cryptography
  544. Message-ID: <16774@well.sf.ca.us>
  545. Date: 20 Mar 90 18:23:32 GMT
  546. Distribution: sci
  547. Lines: 318
  548.  
  549. ___________________________________________________________________
  550. License to copy and use this document and the software described
  551. herein is granted provided it is identified as the "RSA Data
  552. Security, Inc. MD4 Message Digest Algorithm" in all materials
  553. mentioning or referencing this software, function, or document.
  554.  
  555. License is also granted to make derivative works provided that such
  556. works are identified as "derived from the RSA Data Security, Inc. MD4
  557. Message Digest Algorithm" in all material mentioning or referencing
  558. the derived work.
  559.  
  560. RSA Data Security, Inc. makes no representations concerning the
  561. merchantability of this algorithm or software or their suitability
  562. for any specific purpose.  It is provided "as is" without express or
  563. implied warranty of any kind.
  564.  
  565. These notices must be retained in any copies of any part of this
  566. documentation and/or software.
  567.  
  568.  
  569.          The MD4 Message Digest Algorithm
  570.          --------------------------------
  571.             by Ronald L. Rivest
  572.     MIT Laboratory for Computer Science, Cambridge, Mass. 02139
  573.                 and
  574.     RSA Data Security, Inc., Redwood City, California 94065
  575.             (Version 2/17/90 -- Revised)
  576.  
  577.  
  578. Abstract:
  579. ---------
  580.                 
  581. This note describes the MD4 message digest algorithm.  The algorithm
  582. takes as input an input message of arbitrary length and produces as
  583. output a 128-bit ``fingerprint'' or ``message digest'' of the input.
  584. It is conjectured that it is computationally infeasible to produce two
  585. messages having the same message digest, or to produce any message
  586. having a given prespecified target message digest.  The MD4 algorithm
  587. is thus ideal for digital signature applications, where a large file
  588. must be ``compressed'' in a secure manner before being signed with the
  589. RSA public-key cryptosystem.
  590.  
  591. The MD4 algorithm is designed to be quite fast on 32-bit machines.  On
  592. a SUN Sparc station, MD4 runs at 1,450,000 bytes/second.  On a DEC
  593. MicroVax II, MD4 runs at approximately 70,000 bytes/second.  On a 20MHz
  594. 80286, MD4 runs at approximately 32,000 bytes/second.  In addition, the
  595. MD4 algorithm does not require any large substitution tables; the
  596. algorithm can be coded quite compactly.
  597.  
  598. The MD4 algorithm is being placed in the public domain for review and
  599. possible adoption as a standard.  
  600.  
  601. (Note: The document supersedes an earlier draft.  The algorithm described
  602.        here is a slight modification of the one described in the draft.)
  603.  
  604.  
  605. I. Terminology and Notation
  606. ---------------------------
  607.  
  608. In this note a ``word'' is a 32-bit quantity and a byte is an 8-byte
  609. quantity.  A sequence of bits can be interpreted in a natural manner
  610. as a sequence of bytes, where each consecutive group of 8 bits is
  611. interpreted as a byte with the high-order (most significant) bit of
  612. each byte listed first.  Similarly, a sequence of bytes can be
  613. interpreted as a sequence of 32-bit words, where each consecutive
  614. group of 4 bytes is interpreted as a word with the low-order (least
  615. significant) byte given first.
  616.  
  617. Let x_i denote ``x sub i''.  If the subscript is an expression, we
  618. surround it in braces, as in x_{i+1}.  Similarly, we use ^ for
  619. superscripts (exponentiation), so that x^i denotes x to the i-th
  620. power.
  621.  
  622. Let the symbol ``+'' denote addition of words (i.e., modulo-2^32
  623. addition). Let X <<< s denote the 32-bit value obtained by circularly
  624. shifting (rotating) X left by s bit positions.  Let not(X) denote the
  625. bit-wise complement of X, and let X v Y denote the bit-wise OR of X
  626. and Y.  Let X xor Y denote the bit-wise XOR of X and Y, and let XY
  627. denote the bit-wise AND of X and Y.
  628.  
  629.  
  630. II. MD4 Algorithm Description
  631. -----------------------------
  632.  
  633. We begin by supposing that we have a b-bit message as input, and
  634. that we wish to find its message digest.  Here b is an arbitrary
  635. nonnegative integer; b may be zero, it need not be a multiple of 8,
  636. and it may be arbitrarily large. We imagine the bits of the message
  637. written down as follows:
  638.  
  639.     m_0 m_1 ... m_{b-1} .
  640.  
  641. The following five steps are performed to compute the message digest of the
  642. message.
  643.  
  644.  
  645. Step 1. Append padding bits
  646. ---------------------------
  647.  
  648. The message is ``padded'' (extended) so that its length (in bits) is
  649. congruent to 448, modulo 512.  That is, the message is extended so
  650. that it is just 64 bits shy of being a multiple of 512 bits long.
  651. Padding is always performed, even if the length of the message is
  652. already congruent to 448, modulo 512 (in which case 512 bits of
  653. padding are added).
  654.  
  655. Padding is performed as follows: a single ``1'' bit is appended to the
  656. message, and then enough zero bits are appended so that the length in bits
  657. of the padded message becomes congruent to 448, modulo 512.
  658.  
  659.  
  660. Step 2. Append length
  661. ---------------------
  662.  
  663. A 64-bit representation of b (the length of the message before the
  664. padding bits were added) is appended to the result of the previous
  665. step.  In the unlikely event that b is greater than 2^64, then only
  666. the low-order 64 bits of b are used.  (These bits are appended as two
  667. 32-bit words and appended low-order word first in accordance with the
  668. previous conventions.)
  669.  
  670. At this point the resulting message (after padding with bits and with
  671. b) has a length that is an exact multiple of 512 bits.  Equivalently,
  672. this message has a length that is an exact multiple of 16 (32-bit)
  673. words.  Let M[0 ... N-1] denote the words of the resulting message,
  674. where N is a multiple of 16.
  675.  
  676.  
  677. Step 3. Initialize MD buffer
  678. ----------------------------
  679.  
  680. A 4-word buffer (A,B,C,D) is used to compute the message digest.  Here
  681. each of A,B,C,D are 32-bit registers.  These registers are initialized
  682. to the following values (in hexadecimal, low-order bytes first):
  683.  
  684.     word A:    01 23 45 67
  685.     word B:    89 ab cd ef
  686.     word C:    fe dc ba 98
  687.     word D:    76 54 32 10
  688.  
  689.  
  690. Step 4. Process message in 16-word blocks
  691. -----------------------------------------
  692.  
  693. We first define three auxiliary functions that each take as input
  694. three 32-bit words and produce as output one 32-bit word.
  695.  
  696.     f(X,Y,Z)  =  XY v not(X)Z 
  697.     g(X,Y,Z)  =  XY v XZ v YZ 
  698.     h(X,Y,Z)  =  X xor Y xor Z 
  699.  
  700. In each bit position f acts as a conditional: if x then y else z.
  701. (The function f could have been defined using + instead of v since XY
  702. and not(X)Z will never have 1's in the same bit position.)  In each
  703. bit position g acts as a majority function: if at least two of x, y, z
  704. are on, then g has a one in that bit position, else g has a zero. It
  705. is interesting to note that if the bits of X, Y, and Z are independent
  706. and unbiased, the each bit of f(X,Y,Z) will be independent and
  707. unbiased, and similarly each bit of g(X,Y,Z) will be independent and
  708. unbiased.  The function h is the bit-wise ``xor'' or ``parity'' function;
  709. it has properties similar to those of f and g.
  710.  
  711. Do the following:
  712.  
  713. For i = 0 to N/16-1 do    /* process each 16-word block */
  714.     For j = 0 to 15 do: /* copy block i into X */
  715.       Set X[j] to M[i*16+j].
  716.     end /* of loop on j */
  717.     Save A as AA, B as BB, C as CC, and D as DD.
  718.  
  719.     [Round 1]
  720.       Let [A B C D i s] denote the operation
  721.         A = (A + f(B,C,D) + X[i]) <<< s  .
  722.       Do the following 16 operations:
  723.         [A B C D 0 3] 
  724.         [D A B C 1 7] 
  725.         [C D A B 2 11] 
  726.         [B C D A 3 19] 
  727.         [A B C D 4 3] 
  728.         [D A B C 5 7] 
  729.         [C D A B 6 11] 
  730.         [B C D A 7 19] 
  731.         [A B C D 8 3] 
  732.         [D A B C 9 7] 
  733.         [C D A B 10 11] 
  734.         [B C D A 11 19] 
  735.         [A B C D 12 3] 
  736.         [D A B C 13 7] 
  737.         [C D A B 14 11] 
  738.         [B C D A 15 19] 
  739.  
  740.     [Round 2]
  741.       Let [A B C D i s] denote the operation
  742.             A = (A + g(B,C,D) + X[i] + 5A827999) <<< s .
  743.       (The value 5A..99 is a hexadecimal 32-bit constant, written with
  744.       the high-order digit first. This constant represents the square
  745.       root of 2.  The octal value of this constant is 013240474631.
  746.           See Knuth, The Art of Programming, Volume 2
  747.       (Seminumerical Algorithms), Second Edition (1981), Addison-Wesley.
  748.       Table 2, page 660.)
  749.       Do the following 16 operations:
  750.         [A B C D 0  3] 
  751.         [D A B C 4  5] 
  752.         [C D A B 8  9] 
  753.         [B C D A 12 13] 
  754.         [A B C D 1  3] 
  755.         [D A B C 5  5] 
  756.         [C D A B 9  9] 
  757.         [B C D A 13 13] 
  758.         [A B C D 2  3] 
  759.         [D A B C 6  5] 
  760.         [C D A B 10 9] 
  761.         [B C D A 14 13] 
  762.         [A B C D 3  3] 
  763.         [D A B C 7  5] 
  764.         [C D A B 11 9] 
  765.         [B C D A 15 13] 
  766.  
  767.     [Round 3]
  768.       Let [A B C D i s] denote the operation
  769.         A = (A + h(B,C,D) + X[i] + 6ED9EBA1) <<< s
  770.       (The value 6E..A1 is a hexadecimal 32-bit constant, written with
  771.       the high-order digit first. This constant represents the square
  772.       root of 3.  The octal value of this constant is 015666365641.
  773.           See Knuth, The Art of Programming, Volume 2
  774.       (Seminumerical Algorithms), Second Edition (1981), Addison-Wesley.
  775.       Table 2, page 660.)
  776.       Do the following 16 operations:
  777.         [A B C D 0  3] 
  778.         [D A B C 8  9] 
  779.         [C D A B 4  11] 
  780.         [B C D A 12 15] 
  781.         [A B C D 2  3] 
  782.         [D A B C 10 9] 
  783.         [C D A B 6  11] 
  784.         [B C D A 14 15] 
  785.         [A B C D 1  3] 
  786.         [D A B C 9  9] 
  787.         [C D A B 5  11] 
  788.         [B C D A 13 15] 
  789.         [A B C D 3  3] 
  790.         [D A B C 11 9] 
  791.         [C D A B 7  11] 
  792.         [B C D A 15 15] 
  793.  
  794. Then perform the following additions:
  795.         A = A + AA
  796.         B = B + BB
  797.         C = C + CC
  798.         D = D + DD
  799. (That is, each of the four registers is incremented by the value it had
  800. before this block was started.)
  801.  
  802. end /* of loop on i */
  803.  
  804.  
  805. Step 5. Output
  806. --------------
  807.  
  808. The message digest produced as output is A,B,C,D.
  809. That is, we begin with the low-order byte of A, and end with the
  810. high-order byte of D.
  811.  
  812. This completes the description of MD4.  A reference implementation in
  813. C is given in the Appendix.
  814.  
  815.  
  816. III. Extensions
  817. ---------------
  818.  
  819. If more than 128 bits of output are required, then the following
  820. procedure is recommended to obtain a 256-bit output.  (There is no
  821. provision made for obtaining more than 256 bits.)
  822.  
  823. Two copies of MD4 are run in parallel over the input.  The first copy
  824. is standard as described above.  The second copy is modified as follows.
  825.  
  826. The initial state of the second copy is:
  827.     word A:    00 11 22 33
  828.     word B:    44 55 66 77
  829.     word C:    88 99 aa bb
  830.     word D:    cc dd ee ff
  831.  
  832. The magic constants in rounds 2 and 3 for the second copy of MD4 are
  833. changed from sqrt(2) and sqrt(3) to cuberoot(2) and cuberoot(3):
  834.                 Octal        Hex
  835.     Round 2 constant    012050505746    50a28be6 
  836.     Round 3 constant    013423350444    5c4dd124
  837.  
  838. Finally, after every 16-word block is processed (including the last
  839. block), the values of the A registers in the two copies are exchanged.
  840.  
  841. The final message digest is obtaining by appending the result of the
  842. second copy of MD4 to the end of the result of the first copy of MD4.
  843.  
  844.  
  845. IV. Summary
  846. ------------
  847.  
  848. The MD4 message digest algorithm is simple to implement, and provides
  849. a ``fingerprint'' or message digest of a message of arbitrary length.
  850.  
  851. It is conjectured that the difficulty of coming up with two messages
  852. having the same message digest is on the order of 2^64 operations, and
  853. that the difficulty of coming up with any message having a given
  854. message digest is on the order of 2^128 operations.  The MD4 algorithm
  855. has been carefully scrutinized for weaknesses.  It is, however, a
  856. relatively new algorithm and further security analysis is of course
  857. justified, as is the case with any new proposal of this sort.  The
  858. level of security provided by MD4 should be sufficient for
  859. implementing very high security hybrid digital signature schemes based
  860. on MD4 and the RSA public-key cryptosystem.
  861.  
  862. V. Acknowledgements
  863. -------------------
  864.  
  865. I'd like to thank Don Coppersmith, Burt Kaliski, Ralph Merkle, and
  866. Noam Nisan for numerous helpful comments and suggestions.
  867.  
  868.